Split out from #763.

Motivation:

Reduce allocation and dispatch overhead when one- and three-argument builtins are called through the dynamic Val.Func.apply1 / apply3 path.

Key Design Decision:

Keep the optimization local and semantics-preserving. Builtin2 already has an exact-arity apply2 override; this adds matching Builtin1.apply1 and Builtin3.apply3 overrides. Exact positional calls directly invoke the structured evalRhs overload and skip constructing an intermediate Array. Non-exact paths still fall back to the generic parent application path.

Correctness:

• The direct path matches the existing Builtin1.apply / Builtin3.apply exact positional behavior: force the supplied Eval values, then call the typed evalRhs.
• Named arguments, missing defaults, too many arguments, and other non-exact calls still use the generic function application logic.
• Static Expr.ApplyBuiltin1 / Expr.ApplyBuiltin3 paths are unchanged; this only helps dynamic builtin calls such as a builtin stored in a local or returned from another function.

Modification:

• Add Builtin1.apply1.
• Add Builtin3.apply3.

Validation:

• ./mill --no-server 'sjsonnet.jvm[3.3.7].compile'
• ./mill --no-server 'sjsonnet.jvm[3.3.7].test' (141/141, SUCCESS)
• ./mill --no-server 'sjsonnet.jvm[3.3.7].checkFormat'
• ./mill --no-server '_.jvm[_].__.test' (1104/1104, SUCCESS)
• Dynamic builtin smoke checks:
  • local f = std.length; f([1, 2, 3]) -> 3
  • local f = std.substr; f("abcdef", 1, 3) -> "bcd"
  • local f = std.substr; f(str="abcdef", from=1, len=3) -> "bcd"

Hyperfine:

Toolchain:

• hyperfine 1.20.0
• --warmup 3 --min-runs 25 for targeted dynamic builtin benchmarks
• --warmup 3 --min-runs 20 for realistic2
• JVM assemblies built with ./mill --no-server show 'sjsonnet.jvm[3.3.7].assembly'
• Base: upstream/master at c04fc804
• Branch: 2067d8b5

Targeted Builtin1 dynamic call benchmark:

local identity(x) = x;
local len = identity(std.length);
std.foldl(
  function(acc, i) acc + len("abcdef"),
  std.range(1, 5000000),
  0
)

Result: statistically neutral in this hyperfine run.

Targeted Builtin3 dynamic call benchmark:

local identity(x) = x;
local substr = identity(std.substr);
std.foldl(
  function(acc, i) acc + std.length(substr("abcdef", 1, 3)),
  std.range(1, 3000000),
  0
)

Result: branch was faster in this run, but variance is high.

End-to-end realistic2:

Result: branch was faster in this run; due JVM-startup and system noise, treat this as a non-regression signal rather than a guaranteed 1.27x speedup.